/**
 *
 */
package com.evangelion.core.controller;

import com.evangelion.core.bean.Alumno;
import com.evangelion.core.bean.Examen;
import com.evangelion.core.bean.Profesor;
import com.evangelion.core.daoImpl.ConnectionUtil;
import com.evangelion.core.pojo.ExamenPracticoSearchForm;
import com.evangelion.core.utils.ExamenConverter;
import com.evangelion.core.utils.MensajesFace;
import com.evangelion.web.filter.SecurityUtils;
import net.sf.jasperreports.engine.*;
import net.sf.jasperreports.engine.util.JRLoader;
import org.apache.commons.lang3.StringUtils;
import org.primefaces.context.RequestContext;
import org.primefaces.model.DefaultStreamedContent;
import org.primefaces.model.LazyDataModel;
import org.primefaces.model.SortOrder;
import org.primefaces.model.chart.CartesianChartModel;
import org.primefaces.model.chart.ChartSeries;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.PostConstruct;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.context.FacesContext;
import javax.servlet.http.HttpServletRequest;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.io.Serializable;
import java.sql.Connection;
import java.util.*;

/**
 * @author Rick Chen
 */
@ManagedBean
@ViewScoped
public class DgtController extends MensajesFace implements Serializable {

    private Examen examen;

    private Examen examenResultado;

    private List<Examen> examenList;

    private Date fechadesde;

    private Date fechahasta;

    private Date fechadesdeGrafic;

    private Date fechahastaGrafic;

    private LazyDataModel<Alumno> listAlumno;

    private String searchParamAlumno;

    private String searchParamAlumno3;

    private String valor;

    boolean renderTable;

    private List<Examen> examenList2;

    private List<Examen> examenresultadoList;

    private List<Examen> examenResPresentado;

    private String tipoprueba;

    private String searchParamProfesor;

    private LazyDataModel<Profesor> listProfesor;

    private boolean renderTableProfesor;

    private CartesianChartModel graficMatriculaMensual;

    private CartesianChartModel graficMatMensualPermiso;

    private CartesianChartModel graficResMensual;

    private DefaultStreamedContent dc;

    private Examen practicoExam;
    private String practicoExamProfesor;

    private ExamenPracticoSearchForm practicoSearchForm = new ExamenPracticoSearchForm();
    private LazyDataModel<Profesor> practicoProfesorList;
    private boolean renderTablePracticoProfessor;

    @PostConstruct
    public void init() {
        super.init();

        practicoExam = new Examen();

        examen = new Examen();
        examenList = new ArrayList<Examen>();
        examenResPresentado = new ArrayList<Examen>();

        examenList2 = new ArrayList<Examen>();
        examenResultado = new Examen();
        examenresultadoList = new ArrayList<Examen>();//new ExamenConverter(new ArrayList<Examen>()).linkTypesDB;
        searchParamAlumno3 = "";
        searchParamProfesor = "";
        graficMatriculaMensual = new CartesianChartModel();
        graficMatMensualPermiso = new CartesianChartModel();
        graficResMensual = new CartesianChartModel();
    }

    public void searchPratico() {
        List<String> pruebaList = new ArrayList<String>();

        pruebaList.add("Mecanico");
        pruebaList.add("Especifico");
        pruebaList.add("Circuito abierto");
        pruebaList.add("Circuito cerrado");
        if (StringUtils.isEmpty(practicoSearchForm.getProfessorStr())) {
            practicoSearchForm.setProfessor(null);
        }
        examenList2 = examenService.findByRangeDate(practicoSearchForm.getProfessor(), seccion, practicoSearchForm.getFechaDesde(), practicoSearchForm.getFechaHasta(), pruebaList);

    }

    public void onRowSelectPracticoProfesor(Profesor professor) {
        renderTablePracticoProfessor = false;
        practicoSearchForm.setProfessor(professor);
        practicoSearchForm.setProfessorStr(professor.getNombres() + " " + professor.getApellidos());
    }

    public void printPratico() {
        FacesContext context = FacesContext.getCurrentInstance();
        HttpServletRequest request = (HttpServletRequest) context.getExternalContext().getRequest();

        List pruebaList = new ArrayList();
        pruebaList.add("Mecanico");
        pruebaList.add("Especifico");
        pruebaList.add("Circuito abierto");
        pruebaList.add("Circuito cerrado");

        practicoSearchForm.setSeccion(seccion);

        Map parameters = new HashMap();
        parameters.put("rpt_prueba_list", pruebaList);
        parameters.put("rpt_seccion_id", "" + SecurityUtils.getSeccion(request).getId());

        Calendar calendar = Calendar.getInstance();
        if (null == practicoSearchForm.getFechaDesde()) {
            calendar.add(Calendar.YEAR, -1);
            parameters.put("rpt_desde", calendar.getTime());
        } else {
            parameters.put("rpt_desde", practicoSearchForm.getFechaDesde());
        }

        if (null == practicoSearchForm.getFechaHasta()) {
            calendar = Calendar.getInstance();
            calendar.add(Calendar.DAY_OF_MONTH, 1);
            parameters.put("rpt_hasta", calendar.getTime());
        } else {
            parameters.put("rpt_hasta", practicoSearchForm.getFechaHasta());
        }

        List<Profesor> profesors = examenService.findProfessor(practicoSearchForm, pruebaList);

        printPraticoReport(profesors, parameters, "ExamenPracticoReport");
    }

    public void printPraticoReport(List<Profesor> profesors, Map parameters, String reportName) {
        try {

            String urlMaster = ConnectionUtil.getServletContext().getRealPath(REPORT_FOLDER + reportName + ".jasper");
            JasperReport reporteMaster = null;
            try {
                reporteMaster = (JasperReport) JRLoader.loadObject(urlMaster);
            } catch (Exception e) {
                e.printStackTrace();
            }

            List<JasperPrint> reportsList = new ArrayList<JasperPrint>();
            Connection conexion = connectionUtil.getConnection();
            for (Profesor profesor : profesors) {
                parameters.put("rpt_profesor_id", "" + profesor.getId());
                parameters.put("rpt_profesor_nif", profesor.getNif());
                parameters.put("rpt_profesor_name", profesor.getNombres());

                JasperPrint print = JasperFillManager.fillReport(reporteMaster, parameters, conexion);
                reportsList.add(print);
            }

            byte[] bytes = JasperExportManager.exportReportToPdf(mergeReport(reportsList));

            if (bytes.length >= 1211 && bytes.length <= 1400) {
                dc = null;
            } else {
                Calendar calendar = Calendar.getInstance();

                InputStream stream = new ByteArrayInputStream(bytes);
                dc = new DefaultStreamedContent(stream, "application/pdf", "/general/teorico_" + calendar.getTimeInMillis() + ".pdf");
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    protected JasperPrint mergeReport(List<JasperPrint> reportList) throws Exception {

        JasperPrint jrPrint = new JasperPrint();

        if (null == reportList || reportList.size() == 0) {
            return jrPrint;
        }

        JasperPrint firstPagePrint = reportList.get(0);

        // set the report layout
        jrPrint.setOrientation(firstPagePrint.getOrientationValue());
        jrPrint.setLocaleCode(firstPagePrint.getLocaleCode());

        jrPrint.setPageHeight(firstPagePrint.getPageHeight());

        jrPrint.setPageWidth(firstPagePrint.getPageWidth());

        jrPrint.setTimeZoneId(firstPagePrint.getTimeZoneId());

        jrPrint.setName(firstPagePrint.getName());

        // get each report and merge it 1 by 1
        for (JasperPrint jp : reportList) {
            List list = jp.getPages();
            // Merging the reports into 1 single report
            for (Object aList : list) {
                jrPrint.addPage((JRPrintPage) aList);
            }
        }
        return jrPrint;

    }

    public void printTeorico() {
        FacesContext context = FacesContext.getCurrentInstance();
        HttpServletRequest request = (HttpServletRequest) context.getExternalContext().getRequest();

        Map parameters = new HashMap();
        parameters.put("rpt_prueba", "Teorico");
        parameters.put("rpt_seccion_id", "" + SecurityUtils.getSeccion(request).getId());
        Calendar calendar = Calendar.getInstance();
        if (null == fechadesde) {
            calendar.add(Calendar.YEAR, -1);
            parameters.put("rpt_desde", calendar.getTime());
        } else {
            parameters.put("rpt_desde", fechadesde);
        }

        if (null == fechahasta) {
            calendar = Calendar.getInstance();
            calendar.add(Calendar.DAY_OF_MONTH, 1);
            parameters.put("rpt_hasta", calendar.getTime());
        } else {
            parameters.put("rpt_hasta", fechahasta);
        }

        printReport(parameters, "ExamenTeoricoReport");
    }

    public void printReport(Map parameters, String reportName) {
        try {

            String urlMaster = ConnectionUtil.getServletContext().getRealPath(REPORT_FOLDER + reportName + ".jasper");
            JasperReport reporteMaster = null;
            try {
                reporteMaster = (JasperReport) JRLoader.loadObject(urlMaster);
            } catch (Exception e) {
                e.printStackTrace();
            }

            Connection conexion = connectionUtil.getConnection();
            JasperPrint print = JasperFillManager.fillReport(reporteMaster, parameters, conexion);
            byte[] bytes = JasperExportManager.exportReportToPdf(print);

            if (bytes.length >= 1211 && bytes.length <= 1400) {
                dc = null;
            } else {
                Calendar calendar = Calendar.getInstance();

                InputStream stream = new ByteArrayInputStream(bytes);
                dc = new DefaultStreamedContent(stream, "application/pdf", "/general/teorico_" + calendar.getTimeInMillis() + ".pdf");
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public void savePractico() {

        practicoExam.setEstadoexamen("Activo");

        practicoExam.setCliente(usuario.getCliente());
        practicoExam.setSeccion(seccion);
        examenService.save(practicoExam);

        init();
        msgCambiosGuardados();
    }

    public void saveTeorico() {

        examen.setPrueba("Teorico");

        examen.setEstadoexamen("Activo");

        examen.setCliente(usuario.getCliente());
        examen.setSeccion(seccion);
        examenService.save(examen);

        init();
        msgCambiosGuardados();
    }

    public void save(String prueba) {

        if (prueba.equals("Resultado")) {
            examenResultado.setClienteregexamen(usuario.getCliente());
            examenResultado.setFechaingexamen(new Date());
            examenResultado.setEstadoexamen("Presentado");
            examenService.save(examenResultado);
            if (examenResultado.getFechaproxexamen() != null) {
                Examen exa = new Examen();
                exa.setAlumno(examenResultado.getAlumno());
                exa.setCliente(examenResultado.getCliente());
                exa.setConvocatoria(examenResultado.getConvocatoria());
                exa.setEstado("Repetidor");
                exa.setEstadoexamen("Activo");
                exa.setFallo(examenResultado.getFallo());
                exa.setFechaexamen(examenResultado.getFechaproxexamen());
                exa.setPermiso(examenResultado.getPermiso());
                exa.setPrueba(examenResultado.getPrueba());
                exa.setSeccion(examenResultado.getSeccion());
                exa.setSolicitud(examenResultado.getSolicitud());
                examenService.save(exa);
            }
//            examenresultadoList = new ExamenConverter(examenService.findByAlumnoEstado(seccion, examenResultado.getAlumno(), "Activo")).linkTypesDB;
//            
//            examenResPresentado = examenService.findByAlumnoEstado(seccion, examenResultado.getAlumno(), "Presentado");

        } else {
            if (prueba.equals("Practico")) {
                //examen = examen2;
            } else {
                examen.setPrueba(prueba);
            }
            examen.setEstadoexamen("Activo");

            examen.setCliente(usuario.getCliente());
            examen.setSeccion(seccion);
            examenService.save(examen);

        }
        init();
        msgCambiosGuardados();

    }

    public void selecExamen(Alumno alumno, String tipo) {
        examen.setAlumno(alumno);
        if (tipo.equals("Teorico")) {
            searchParamAlumno = alumno.getNombres() + " " + alumno.getApellidos();
            RequestContext.getCurrentInstance().update(":formgdt:tabViewgdt:idalumno");
        }
//        else {
//            searchParamAlumno2 = alumno.getNombres() + " " + alumno.getApellidos();
//            RequestContext.getCurrentInstance().update(":formgdt:tabViewgdt:idalumno2");
//        }
    }

    public void onRowSelectAlumno(Alumno alumno) {
        renderTable = false;

        if (tipoprueba.equals("Teorico")) {
            examen.setAlumno(alumno);
            searchParamAlumno = alumno.getNombres() + " " + alumno.getApellidos();
            RequestContext.getCurrentInstance().update(":formgdt:tabViewgdt:idalumno");
        }
//        if (tipoprueba.equals("Practico")) {
//            practicoExam.setAlumno(alumno);
//            searchParamAlumno2 = alumno.getNombres() + " " + alumno.getApellidos();
//            RequestContext.getCurrentInstance().update(":formgdt:tabViewgdt:idalumno2");
//        }
        if (tipoprueba.equals("Resultado")) {
            examenresultadoList = new ExamenConverter(examenService.findByAlumnoEstado(seccion, alumno, "Activo")).linkTypesDB;
            if (examenresultadoList.isEmpty()) {
                msgAdvertencia("Este alumno no posee examenes pendientes por realizar");
            }
            examenResPresentado = examenService.findByAlumnoEstado(seccion, alumno, "Presentado");
            searchParamAlumno3 = alumno.getNombres() + " " + alumno.getApellidos();
            RequestContext.getCurrentInstance().update(":formgdt:tabViewgdt:idalumnoresultado");
        }
    }

    public void buscarListaAlumno(String tipoprueba) {
        this.tipoprueba = tipoprueba;
        if (tipoprueba.equals("Teorico")) {
            valor = searchParamAlumno;
            configDataModelFacAlum();
        }
//        if (tipoprueba.equals("Practico")) {
//            valor = searchParamAlumno2;
//            configDataModelFacAlum();
//        }
        if (tipoprueba.equals("Resultado")) {
            valor = searchParamAlumno3;
            configDataModelFacAlum();
        }

        renderTable = true;
    }

    @SuppressWarnings("serial")
    public void configDataModelFacAlum() {
        listAlumno = new LazyDataModel<Alumno>() {
            @Override
            public List<Alumno> load(int start, int max, String arg2, SortOrder arg3, Map<String, String> arg4) {
                if (valor == null) {
                    valor = "";
                }
                return serviceAlunmo.searchByNifNombre(seccion, valor, start, max);

            }
        };
        listAlumno.setRowCount(serviceAlunmo.countPage(seccion, valor));
    }

    public void onRowSelectProfesor(Profesor profes) {
        renderTableProfesor = false;
        examenResultado.setProfesor(profes);
        searchParamProfesor = examenResultado.getProfesor().getNombres() + " " + examenResultado.getProfesor().getApellidos();
    }

    public void buscarListaProfesor() {
        configDataModel();
        renderTableProfesor = true;
    }

    @SuppressWarnings("serial")
    public void configDataModel() {
        listProfesor = new LazyDataModel<Profesor>() {
            @Override
            public List<Profesor> load(int start, int max, String arg2, SortOrder arg3, Map<String, String> arg4) {
                if (searchParamProfesor == null) {
                    searchParamProfesor = "";
                }
                return profesorService.searchByNifNombre(seccion, searchParamProfesor, start, max);
            }
        };
        listProfesor.setRowCount(profesorService.countPage(seccion, searchParamProfesor));
    }

    public void buscarListaExamen(String prueba) {
        List<String> pruebaList = new ArrayList<String>();
        if (prueba.equals("Teorico")) {
            pruebaList.add("Teorico");
            examenList = examenService.findByRangeDate(null, seccion, fechadesde, fechahasta, pruebaList);
        }
    }

    public void matriculaGrafic() {

        List<Object[]> matriculaMensual = fas.matriculasMensuales(seccion, fechadesdeGrafic, fechahastaGrafic);
        graficMatriculaMensual = new CartesianChartModel();

        ChartSeries mat = new ChartSeries();
        mat.setLabel("Matricula");
        for (int i = 0; i < matriculaMensual.size(); i++) {
            mat.set(matriculaMensual.get(i)[1].toString(), (Long) matriculaMensual.get(i)[0]);
        }

        graficMatriculaMensual.addSeries(mat);
        //--------------------------
        graficMatMensualPermiso = new CartesianChartModel();
        List<Object[]> matriculaMenPerm = fas.matriculasMensualesPermiso(seccion, fechadesdeGrafic, fechahastaGrafic, null);
        String valorPermiso = "";
        HashMap<String, List<Object[]>> map = new HashMap<String, List<Object[]>>();
        HashMap<String, String> keys = new HashMap<String, String>();

        for (int i = 0; i < matriculaMenPerm.size(); i++) {
            List<Object[]> lista = new ArrayList<Object[]>();
            if (map.containsKey(matriculaMenPerm.get(i)[2] + "")) {
                lista = map.get(matriculaMenPerm.get(i)[2] + "");
            }
            keys.put(matriculaMenPerm.get(i)[1] + "", matriculaMenPerm.get(i)[1] + "");
            lista.add(matriculaMenPerm.get(i));
            map.put(matriculaMenPerm.get(i)[2] + "", lista);
        }

        for (Map.Entry<String, List<Object[]>> entry : map.entrySet()) {
            String string = entry.getKey();
            HashMap<String, String> mapCompare = new HashMap<String, String>();
            mat = new ChartSeries();
            for (Object[] objects : entry.getValue()) {
                if (!string.equals(valorPermiso)) {
//                    if (!valorPermiso.equals("")) {
//                        graficMatMensualPermiso.addSeries(mat);
//                    }
                    valorPermiso = string;
                    mat.setLabel(string);
                }
                mapCompare.put(objects[1].toString(), objects[2].toString());
                mat.set(objects[1].toString(), (Long) objects[0]);
            }
            for (Map.Entry<String, String> key : keys.entrySet()) {
                if (!mapCompare.containsKey(key.getKey())) {
                    mat.set(key.getValue(), 0);
                }
            }
            graficMatMensualPermiso.addSeries(mat);
        }

        ResultadosGrafic();

    }

    public void ResultadosGrafic() {

        List<Object[]> resultadoMensual = examenService.examenResultadoMensual(seccion, fechadesdeGrafic, fechahastaGrafic);
        graficResMensual = new CartesianChartModel();
        String valorPermiso = "";
        HashMap<String, List<Object[]>> map = new HashMap<String, List<Object[]>>();
        HashMap<String, String> keys = new HashMap<String, String>();
        for (int i = 0; i < resultadoMensual.size(); i++) {
            List<Object[]> lista = new ArrayList<Object[]>();
            if (map.containsKey(resultadoMensual.get(i)[2] + "")) {
                lista = map.get(resultadoMensual.get(i)[2] + "");
            }
            lista.add(resultadoMensual.get(i));
            keys.put(resultadoMensual.get(i)[1] + "", resultadoMensual.get(i)[1] + "");
            map.put(resultadoMensual.get(i)[2] + "", lista);
            System.out.println("......................................" + resultadoMensual.get(i)[0] + ".." + resultadoMensual.get(i)[1] + "-" + resultadoMensual.get(i)[2]);
        }
        ChartSeries mat;
        for (Map.Entry<String, List<Object[]>> entry : map.entrySet()) {
            String string = entry.getKey();
            mat = new ChartSeries();
            HashMap<String, String> mapCompare = new HashMap<String, String>();
            for (Object[] objects : entry.getValue()) {

                if (!string.equals(valorPermiso)) {
                    valorPermiso = string;
                    mat.setLabel(string);
                    System.out.println("Etiqueta" + string);
                }
                mapCompare.put(objects[1].toString(), objects[2].toString());
                System.out.println("objects[1].toString(), (Long) objects[0]...." + objects[1].toString() + "-" + (Long) objects[0]);
                mat.set(objects[1].toString(), (Long) objects[0]);
            }
            for (Map.Entry<String, String> key : keys.entrySet()) {
                if (!mapCompare.containsKey(key.getKey())) {
                    mat.set(key.getValue(), 0);
                }
            }
            graficResMensual.addSeries(mat);
        }

    }

    public void searchProfesor() {
        practicoProfesorList = searchProfessor(this.getPracticoSearchForm().getProfessorStr(), seccion);
        renderTablePracticoProfessor = true;
    }

    public void searchExamProfesor() {
        practicoProfesorList = searchProfessor(this.practicoExamProfesor, seccion);
    }

    public void onRowSelectExamProfesor(Profesor professor) {
        this.practicoExam.setProfesor(professor);
        this.practicoExamProfesor = professor.getNombres();
    }

    public Examen getExamen() {
        return examen;
    }

    public void setExamen(Examen examen) {
        this.examen = examen;
    }

    public List<Examen> getExamenList() {
        return examenList;
    }

    public void setExamenList(List<Examen> examenList) {
        this.examenList = examenList;
    }

    public Date getFechadesde() {
        return fechadesde;
    }

    public void setFechadesde(Date fechadesde) {
        this.fechadesde = fechadesde;
    }

    public Date getFechahasta() {
        return fechahasta;
    }

    public void setFechahasta(Date fechahasta) {
        this.fechahasta = fechahasta;
    }

    public LazyDataModel<Alumno> getListAlumno() {
        return listAlumno;
    }

    public void setListAlumno(LazyDataModel<Alumno> listAlumno) {
        this.listAlumno = listAlumno;
    }

    public String getSearchParamAlumno() {
        return searchParamAlumno;
    }

    public void setSearchParamAlumno(String searchParamAlumno) {
        this.searchParamAlumno = searchParamAlumno;
    }

    public boolean isRenderTable() {
        return renderTable;
    }

    public void setRenderTable(boolean renderTable) {
        this.renderTable = renderTable;
    }

    public List<Examen> getExamenList2() {
        return examenList2;
    }

    public void setExamenList2(List<Examen> examenList2) {
        this.examenList2 = examenList2;
    }

    //
//    public String getSearchParamAlumno2() {
//        return searchParamAlumno2;
//    }
//
//
//    public void setSearchParamAlumno2(String searchParamAlumno2) {
//        this.searchParamAlumno2 = searchParamAlumno2;
//    }
    public String getSearchParamAlumno3() {
        return searchParamAlumno3;
    }

    public void setSearchParamAlumno3(String searchParamAlumno3) {
        this.searchParamAlumno3 = searchParamAlumno3;
    }

    public List<Examen> getExamenresultadoList() {
        return examenresultadoList;
    }

    public void setExamenresultadoList(List<Examen> examenresultadoList) {
        this.examenresultadoList = examenresultadoList;
    }

    public Examen getExamenResultado() {
        return examenResultado;
    }

    public void setExamenResultado(Examen examenResultado) {
        this.examenResultado = examenResultado;
    }

    public String getSearchParamProfesor() {
        return searchParamProfesor;
    }

    public void setSearchParamProfesor(String searchParamProfesor) {
        this.searchParamProfesor = searchParamProfesor;
    }

    public boolean isRenderTableProfesor() {
        return renderTableProfesor;
    }

    public void setRenderTableProfesor(boolean renderTableProfesor) {
        this.renderTableProfesor = renderTableProfesor;
    }

    public LazyDataModel<Profesor> getListProfesor() {
        return listProfesor;
    }

    public void setListProfesor(LazyDataModel<Profesor> listProfesor) {
        this.listProfesor = listProfesor;
    }

    public List<Examen> getExamenResPresentado() {
        return examenResPresentado;
    }

    public void setExamenResPresentado(List<Examen> examenResPresentado) {
        this.examenResPresentado = examenResPresentado;
    }

    public Date getFechadesdeGrafic() {
        return fechadesdeGrafic;
    }

    public void setFechadesdeGrafic(Date fechadesdeGrafic) {
        this.fechadesdeGrafic = fechadesdeGrafic;
    }

    public Date getFechahastaGrafic() {
        return fechahastaGrafic;
    }

    public void setFechahastaGrafic(Date fechahastaGrafic) {
        this.fechahastaGrafic = fechahastaGrafic;
    }

    public CartesianChartModel getGraficMatriculaMensual() {
        return graficMatriculaMensual;
    }

    public void setGraficMatriculaMensual(CartesianChartModel graficMatriculaMensual) {
        this.graficMatriculaMensual = graficMatriculaMensual;
    }

    public CartesianChartModel getGraficMatMensualPermiso() {
        return graficMatMensualPermiso;
    }

    public void setGraficMatMensualPermiso(CartesianChartModel graficMatMensualPermiso) {
        this.graficMatMensualPermiso = graficMatMensualPermiso;
    }

    public CartesianChartModel getGraficResMensual() {
        return graficResMensual;
    }

    public void setGraficResMensual(CartesianChartModel graficResMensual) {
        this.graficResMensual = graficResMensual;
    }

    /**
     * @return the dc
     */
    public DefaultStreamedContent getDc() {
        return dc;
    }

    /**
     * @param dc the dc to set
     */
    public void setDc(DefaultStreamedContent dc) {
        this.dc = dc;
    }

    public Examen getPracticoExam() {
        return practicoExam;
    }

    public void setPracticoExam(Examen practicoExam) {
        this.practicoExam = practicoExam;
    }

    public ExamenPracticoSearchForm getPracticoSearchForm() {
        return practicoSearchForm;
    }

    public void setPracticoSearchForm(ExamenPracticoSearchForm practicoSearchForm) {
        this.practicoSearchForm = practicoSearchForm;
    }

    public LazyDataModel<Profesor> getPracticoProfesorList() {
        return practicoProfesorList;
    }

    public void setPracticoProfesorList(LazyDataModel<Profesor> practicoProfesorList) {
        this.practicoProfesorList = practicoProfesorList;
    }

    public boolean isRenderTablePracticoProfessor() {
        return renderTablePracticoProfessor;
    }

    public void setRenderTablePracticoProfessor(boolean renderTablePracticoProfessor) {
        this.renderTablePracticoProfessor = renderTablePracticoProfessor;
    }

    public String getPracticoExamProfesor() {
        return practicoExamProfesor;
    }

    public void setPracticoExamProfesor(String practicoExamProfesor) {
        this.practicoExamProfesor = practicoExamProfesor;
    }
}
